package com.yuncheng.spcyApi.service.impl;

import cn.hutool.core.date.DateUnit;
import cn.hutool.core.date.DateUtil;
import org.apache.commons.collections.CollectionUtils;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.yuncheng.spcyApi.constant.common.SpcyConstant;
import com.yuncheng.spcyApi.controller.LoginSmsController;
import com.yuncheng.spcyApi.entity.SpcyRsJjrk;
import com.yuncheng.spcyApi.mapper.SpcyRsJjrkMapper;
import com.yuncheng.spcyApi.service.ISpcyRsJjrkService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;

import com.yuncheng.common.base.service.impl.BaseServiceImpl;
import utils.Util;
import utils.WorkDateUtils;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.time.Instant;
import java.time.LocalDate;
import java.time.ZoneId;
import java.time.temporal.ChronoField;
import java.time.temporal.ChronoUnit;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;

/**
 * @Description: 审评查验-节假日库
 * @Author: csx
 * @Date: 2023-03-03
 * @Version: V1.0
 */
@Service
public class SpcyRsJjrkServiceImpl extends BaseServiceImpl<SpcyRsJjrkMapper, SpcyRsJjrk> implements ISpcyRsJjrkService {

    private static final Logger log = LoggerFactory.getLogger(LoginSmsController.class);

    @Override
    public Date getJzsj(Date startDate, Integer gzrts) {
        int gzsj = gzrts; // 工作日天数
        List<Date> jbDateList = new ArrayList<>();
        // 加班数据
        List<SpcyRsJjrk> jbList = list(new LambdaQueryWrapper<SpcyRsJjrk>()
                .eq(SpcyRsJjrk::getFjjrlx, SpcyConstant.JJRK_LX_JB));
        List<Date> txDateList = new ArrayList<>();
        if (CollectionUtils.isNotEmpty(jbList)) {
            jbDateList = jbList.stream().map(SpcyRsJjrk::getFjjrsj).collect(Collectors.toList());
        }

        // 调休数据
        List<SpcyRsJjrk> txList = list(new LambdaQueryWrapper<SpcyRsJjrk>()
                .eq(SpcyRsJjrk::getFjjrlx, SpcyConstant.JJRK_LX_TX));
        if (CollectionUtils.isNotEmpty(txList)) {
            txDateList = txList.stream().map(SpcyRsJjrk::getFjjrsj).collect(Collectors.toList());
        }

        Date jzrq = WorkDateUtils.getJzrq(startDate, gzsj, jbDateList, txDateList);

        return jzrq;
    }

    @Override
    public int jsTwoDateBetween(Date kssj, Date jssj) {
        int gzsj = 0; // 工作日天数
        List<Date> jbDateList = new ArrayList<>();

        // 加班数据
        List<SpcyRsJjrk> jbList = list(new LambdaQueryWrapper<SpcyRsJjrk>()
                .eq(SpcyRsJjrk::getFjjrlx, SpcyConstant.JJRK_LX_JB));
        List<Date> txDateList = new ArrayList<>();
        if (CollectionUtils.isNotEmpty(jbList)) {
            jbDateList = jbList.stream().map(SpcyRsJjrk::getFjjrsj).collect(Collectors.toList());
        }

        // 调休数据
        List<SpcyRsJjrk> txList = list(new LambdaQueryWrapper<SpcyRsJjrk>()
                .eq(SpcyRsJjrk::getFjjrlx, SpcyConstant.JJRK_LX_TX));
        if (CollectionUtils.isNotEmpty(txList)) {
            txDateList = txList.stream().map(SpcyRsJjrk::getFjjrsj).collect(Collectors.toList());
        }

        gzsj = WorkDateUtils.calLeaveDays(kssj,jssj,jbDateList,txDateList);

        return gzsj;
    }

    @Override
    public BigDecimal wxDays(Date startTime, Date endTime) {
        int seconds = 0;
        //判断开始时间和结束时间是否是同一天
        Calendar cal1 = Calendar.getInstance();
        Calendar cal2 = Calendar.getInstance();
        cal1.setTime(startTime);
        cal2.setTime(endTime);

        boolean sameDay = cal1.get(Calendar.DAY_OF_YEAR) == cal2.get(Calendar.DAY_OF_YEAR);
        if (sameDay){
            long lDate1 = startTime.getTime();
            long lDate2 = endTime.getTime();
            long diff = (lDate1 < lDate2) ? (lDate2 - lDate1) : (lDate1 - lDate2);
            long diffSecond  = (diff) / (1000);
            BigDecimal bigdiffSecond = BigDecimal.valueOf(diffSecond);
            //如果是同一天就只计算时分秒,返回秒，在外面接收重新处理

            BigDecimal bigString1 = new BigDecimal(bigdiffSecond.toString());
//            log.info("除数：{}",bigString1);

            // // 一天总秒数
            BigDecimal bigString2 = new BigDecimal("86400");
//            log.info("被除数：{}",bigString2);

            // BigDecimal求商,工作秒数 / 一天总秒数，保留两位小时，再进位保留一位小数
            BigDecimal strConsult = new BigDecimal(0);
            strConsult = bigString1.divide(bigString2, 2, RoundingMode.HALF_UP);
            BigDecimal v = BigDecimal.valueOf(strConsult.setScale(1, BigDecimal.ROUND_HALF_UP).doubleValue());

//            log.info("工作日天数：{}",strConsult);
//            log.info("工作日天数：{}",v);
            return v;

        }else {
            //如果不是同一天 返回*.*天 1.先拿到两个时间内的总秒数
            long secondsInADay = 86400;
            long secondDate1 = startTime.getTime();
            long secondDate2 = endTime.getTime();
            long diff = (secondDate1 < secondDate2) ? (secondDate2 - secondDate1) : (secondDate1 - secondDate2);

            long diffSecond = (diff) / (1000);
//            log.info("总时间秒数：{}",diffSecond);

            //休息秒数
            int leaveDays = getLeaveDays(startTime, endTime);
            long xxms = leaveDays * secondsInADay;
//            log.info("休息秒数：{}",xxms);

            //总工作秒数
            BigDecimal zxzmx = BigDecimal.valueOf(diffSecond - xxms);
//            log.info("总工作秒数：{}",zxzmx);

            BigDecimal bigString1 = new BigDecimal(String.valueOf(zxzmx));
//            log.info("除数：{}",bigString1);

            // 一天总秒数
            BigDecimal bigString2 = new BigDecimal("86400");
//            log.info("被除数：{}",bigString2);

            // //BigDecimal求商 工作秒数 / 一天总秒数, 保留两位小时，再进位保留一位小数
            BigDecimal strConsult = new BigDecimal(0);
            strConsult = bigString1.divide(bigString2, 2, RoundingMode.HALF_UP);
            BigDecimal v = BigDecimal.valueOf(strConsult.setScale(1, BigDecimal.ROUND_HALF_UP).doubleValue());

//            log.info("工作日天数：{}",strConsult);
//            log.info("工作日天数：{}",v);
            return v;
        }
    }

    @Override
    public BigDecimal jsPxxs(Date startTime, Date endTime) {
        String oneDayMs = "50400"; // 一天8小时
        int seconds = 0;
        //判断开始时间和结束时间是否是同一天
        Calendar cal1 = Calendar.getInstance();
        Calendar cal2 = Calendar.getInstance();
        cal1.setTime(startTime);
        cal2.setTime(endTime);

        boolean sameDay = cal1.get(Calendar.DAY_OF_YEAR) == cal2.get(Calendar.DAY_OF_YEAR);
        if (sameDay){
            long lDate1 = startTime.getTime();
            long lDate2 = endTime.getTime();
            long diff = (lDate1 < lDate2) ? (lDate2 - lDate1) : (lDate1 - lDate2);
            long diffSecond  = (diff) / (1000);
            BigDecimal bigdiffSecond = BigDecimal.valueOf(diffSecond);
            //如果是同一天就只计算时分秒,返回秒，在外面接收重新处理

            BigDecimal bigString1 = new BigDecimal(bigdiffSecond.toString());
//            log.info("除数：{}",bigString1);

            // // 一天总秒数
            BigDecimal bigString2 = new BigDecimal(oneDayMs);
//            log.info("被除数：{}",bigString2);

            // BigDecimal求商,工作秒数 / 一天总秒数，保留两位小时，再进位保留一位小数
            BigDecimal strConsult = new BigDecimal(0);
            strConsult = bigString1.divide(bigString2, 2, RoundingMode.HALF_UP);
            BigDecimal v = BigDecimal.valueOf(strConsult.setScale(1, BigDecimal.ROUND_HALF_UP).doubleValue());

            String[] split = strConsult.toString().split("\\.");
            int day = Integer.valueOf(split[0]);
            if (day == 0){
                v = v.setScale(0, BigDecimal.ROUND_UP);
//                v = v.setScale(0, BigDecimal.ROUND_HALF_UP);
            }

//            log.info("工作日天数：{}",v);
//            log.info("工作日天数：{}",v);
            return v;

        }else {
            //如果不是同一天 返回*.*天 1.先拿到两个时间内的总秒数
            long secondsInADay = 86400;
            long secondDate1 = startTime.getTime();
            long secondDate2 = endTime.getTime();
            long diff = (secondDate1 < secondDate2) ? (secondDate2 - secondDate1) : (secondDate1 - secondDate2);

            long diffSecond = (diff) / (1000);
//            log.info("总时间秒数：{}",diffSecond);

            //休息秒数
            int leaveDays = getLeaveDays(startTime, endTime);
            long xxms = leaveDays * secondsInADay;
//            log.info("休息秒数：{}",xxms);

            //总工作秒数
            BigDecimal zxzmx = BigDecimal.valueOf(diffSecond - xxms);
//            log.info("总工作秒数：{}",zxzmx);

            BigDecimal bigString1 = new BigDecimal(String.valueOf(zxzmx));
//            log.info("除数：{}",bigString1);

            // 一天总秒数
            BigDecimal bigString2 = new BigDecimal(oneDayMs);
//            log.info("被除数：{}",bigString2);

            // //BigDecimal求商 工作秒数 / 一天总秒数, 保留两位小时，再进位保留一位小数
            BigDecimal strConsult = new BigDecimal(0);
            strConsult = bigString1.divide(bigString2, 2, RoundingMode.HALF_UP);
            BigDecimal v = BigDecimal.valueOf(strConsult.setScale(1, BigDecimal.ROUND_HALF_UP).doubleValue());

//            log.info("工作日天数：{}",strConsult);
//            log.info("工作日天数：{}",v);

            String[] split = v.toString().split("\\.");
            int day = Integer.valueOf(split[0]);

            // 相差天数
            long betweenDay = DateUtil.between(startTime, endTime, DateUnit.DAY);
            if (day > betweenDay){
                v = v.subtract(new BigDecimal("1"));
            }

            return v;
        }
    }

    @Override
    public int getLeaveDays(Date startTime, Date endTime) {
        //首先 在调休表里查询 select * from tiaoxiu where  fjjrsj > starttime and fjjrsj < endtime and fjjrlx = '调休'
        //如果能查出来 说明有调休 查出来的条数 就是要减去的天数
        //select * from tiaoxiu where  fjjrsj > starttime and fjjrsj < endtime and fjjrlx = '加班'
        //如果能查出来 说明有加班 查出来的条数 就是要增加的天数
        //然后丛开始日期到结束日期 算出来天数 然后 获取开始日期的星期几

        //开始日期 2023-09-01 结束日期 2023-09-30 共30天 首先得判断这个时间是否大于7
        //开始日期是 周五  30/7 = 4.XXX  余2  就是周五周六 一天工作一天休息 四 就是上4*5二十天 休4*2八天  21天工作 九天休息 然后各自计算上边俩查询的数量
        //30-4/7 = 2  余下的一天必然是结束日期 剩下的就结束日期循环减去

        List<SpcyRsJjrk> tx =  list(new LambdaQueryWrapper<SpcyRsJjrk>()
                .eq(SpcyRsJjrk::getFjjrlx, SpcyConstant.JJRK_LX_TX)
                .gt(SpcyRsJjrk::getFjjrsj,startTime)
                .lt(SpcyRsJjrk::getFjjrsj,endTime));

        List<SpcyRsJjrk> jb =  list(new LambdaQueryWrapper<SpcyRsJjrk>()
                .eq(SpcyRsJjrk::getFjjrlx, SpcyConstant.JJRK_LX_JB)
                .gt(SpcyRsJjrk::getFjjrsj,startTime)
                .lt(SpcyRsJjrk::getFjjrsj,endTime));

        int gzr = 0;//工作日
        int xx = 0;//休息

        long secondDate1 = startTime.getTime();//那就是这一块 应该直接拿结束日期和开始日期计算区间天数应该有方法 好像没啥问题啊
        long secondDate2 = endTime.getTime();
        long zong = (secondDate2-secondDate1) / 86400000L;

        long yuTime = secondDate2;
        for(int i = 0;i<zong;i++) {
            long yu = yuTime - 86400000L;
            Date yuDay = new Date(yu);
            if(getWeekOfDate(yuDay)){
                gzr++;
            }else{
                xx++;
            }
            yuTime -= 86400000L;
        }
        if(!Util.isEmpty(tx)&&tx.size()>0){
            xx++;
        }
        if(!Util.isEmpty(jb)&&jb.size()>0){
            gzr++;
        }
        return xx;

    }

    /**
     * @param: startTime, endTime
     * @Description: 对开始时间进行 最终判断
     * @auther: lhb
     * @date: 2023/9/6 16:24
     */
    //如果是加班 就直接返回
    //如果不是加班 判断是不是周六周日-然后返回（这个没问题） 继续判断是否调休
    //如果调休 -格式化当前日期 -循环到下一个最近工作日（怎么结束？）
    @Override
    public Date judgeStart(Date startTime, Date endTime) {
        //1.如果在（休息时间和调休时间）非工作日发起开始时间 结束时间为工作日 则拿后面最近的时间当做开始时间
        //例如：开始时间为： 2023-09-03 09:00:00 因为是周日 是休息 所以 如果开始时间是周六周日  则返回开始时间为周一的0时0分0秒
        //开始时间为 2023-09-04 00:00:00

        // 调休数据
        List<Date> txDateList = new ArrayList<>();
        List<SpcyRsJjrk> txList = list(new LambdaQueryWrapper<SpcyRsJjrk>()
                .eq(SpcyRsJjrk::getFjjrlx, SpcyConstant.JJRK_LX_TX)
                .orderByAsc(SpcyRsJjrk::getFjjrsj));
        if (CollectionUtils.isNotEmpty(txList)) {
            txDateList = txList.stream().map(SpcyRsJjrk::getFjjrsj).collect(Collectors.toList());
        }
        boolean tx = WorkDateUtils.isExists(startTime, txDateList);
//        System.out.println("开始时间是否调休：" + tx);

        //加班数据
        List<Date> jbDateList = new ArrayList<>();
        List<SpcyRsJjrk> jbList = list(new LambdaQueryWrapper<SpcyRsJjrk>()
                .eq(SpcyRsJjrk::getFjjrlx, SpcyConstant.JJRK_LX_JB)
                .orderByAsc(SpcyRsJjrk::getFjjrsj));
        if (CollectionUtils.isNotEmpty(jbList)) {
            jbDateList = jbList.stream().map(SpcyRsJjrk::getFjjrsj).collect(Collectors.toList());
        }
        boolean jb = WorkDateUtils.isExists(startTime, jbDateList);
//        System.out.println("开始时间是否加班：" + jb);

        long secondsInADay = 86400;
        //1.判断开始时间：是不是周六周日
        Date flag = startTime;
        Calendar cal = Calendar.getInstance();
        cal.setTime(flag);
        int week = cal.get(Calendar.DAY_OF_WEEK) - 1; //获取星期几
        long hour = cal.get(Calendar.HOUR_OF_DAY) * 3600; //获取小时-转为秒
        long minute = cal.get(Calendar.MINUTE) * 60; //获取分钟-转为秒
        long second = cal.get(Calendar.SECOND); //获取秒
        long zongms = hour + minute + second;

        //判断今天是否是加班
        if (!jb) {
            if (week == 0) {//0为周日，6为周六   0就加一天 6就加两天
                long lDate1 = (startTime.getTime()) / 1000L;
                long ms = lDate1 + (secondsInADay - zongms);
                long milliseconds = ms * 1000L; // 将秒数转换为毫秒数
                Date startDate = new Date(milliseconds); // 使用毫秒数创建Date对象
//                System.out.println("周日毫秒数创建成功");
                return startDate;
            } else if (week == 6) {
                long lDate1 = (startTime.getTime()) / 1000L;
                long ms = lDate1 + (secondsInADay - zongms) + secondsInADay;
                long milliseconds = ms * 1000L; // 将秒数转换为毫秒数
                Date startDate = new Date(milliseconds); // 使用毫秒数创建Date对象
//                System.out.println("周六毫秒数创建成功");
                return startDate;
            } else if (tx) {//判断今天是否调休
                Date stdate = initializeDate(startTime);//10.2
                Date eddate = initializeDate(endTime);//10.6
                long day = getDay(stdate, eddate);//5
                Date notTx = new Date();
                if (day > 1) {//如果开始日期和结束日期为同一天 就只需要判断当天是否为调休日
                    long sTime = stdate.getTime();
                    Date newDate = new Date(sTime); // 使用毫秒数创建Date对象
//                    System.out.println("毫秒数创建成功" + newDate);
                    for (int i = 0; i < txDateList.size(); i++) {
                        if (sTime < txDateList.get(i).getTime()) {//如果小于 节假日 就加一天 然后拿加一天的日期和节假日比较
                            sTime += 86400000;
                            newDate = new Date(sTime);
//                            System.out.println("第" + i + "次 毫秒数创建成功" + newDate);
                        }
                        if (sTime == txDateList.get(i).getTime()) {//如果等于 节假日 就加一天 然后拿加一天的日期和节假日比较
                            sTime += 86400000;
                            newDate = new Date(sTime);
//                            System.out.println("第" + i + "次 毫秒数创建成功" + newDate);
                        }
                        if (i < txDateList.size() - 1) {
                            if (sTime < txDateList.get(i + 1).getTime()) {
                                notTx = new Date(sTime);
                                break;
                            }
                        } else {
                            notTx = new Date(sTime);
                            break;
                        }
                    }
//                    System.out.println("第一个非调休日期：" + notTx);//那么这个日期 是可能大于结束日期 如果大于，就给他提示一个该区间 没有非调休日期
                } else {
                    for (Date txL : txDateList) {
                        if (txL.getTime() == stdate.getTime()) {//说明是调休
                            notTx = new Date(txL.getTime());
                        } else {
                            //给他提示一个该区间 没有非调休日期
                        }
                    }
//                    System.out.println("调休日为：" + notTx);
                }
//                System.out.println("返回日期为：----------" + notTx);
                return notTx;

            }
        } else {
//            System.out.println("今天是工作日：" + startTime);
            return startTime;
        }
        return flag;
    }


    /**
     * @param: startTime, endTime
     * @Description: 对结束时间进行 最终判断
     * @auther: lhb
     * @date: 2023/9/6 18:46
     */

    @Override
    public Date judgeEnd(Date startTime, Date endTime) {
        //1.如果在（休息时间和调休时间）非工作日的结束时间  则拿后面最近的时间当做结束时间
        //例如：结束时间为： 2023-09-03 09:00:00 则结束时间为 2023-09-04 00:00:00


        // 调休数据
        List<Date> txDateList = new ArrayList<>();
        List<SpcyRsJjrk> txList = list(new LambdaQueryWrapper<SpcyRsJjrk>()
                .eq(SpcyRsJjrk::getFjjrlx, SpcyConstant.JJRK_LX_TX));
        if (CollectionUtils.isNotEmpty(txList)) {
            txDateList = txList.stream().map(SpcyRsJjrk::getFjjrsj).collect(Collectors.toList());
        }
        boolean tx = WorkDateUtils.isExists(endTime, txDateList);
//        System.out.println("结束时间是否调休：" + tx);

        //加班数据
        List<Date> jbDateList = new ArrayList<>();
        List<SpcyRsJjrk> jbList = list(new LambdaQueryWrapper<SpcyRsJjrk>()
                .eq(SpcyRsJjrk::getFjjrlx, SpcyConstant.JJRK_LX_JB));
        if (CollectionUtils.isNotEmpty(jbList)) {
            jbDateList = jbList.stream().map(SpcyRsJjrk::getFjjrsj).collect(Collectors.toList());
        }
        boolean jb = WorkDateUtils.isExists(endTime, jbDateList);
//        System.out.println("结束时间是否加班：" + jb);

        long secondsInADay = 86400;
        //1.判断结束时间：是不是周六周日
        Date flag = endTime;
        Calendar cal = Calendar.getInstance();
        cal.setTime(flag);
        int week = cal.get(Calendar.DAY_OF_WEEK) - 1; //获取星期几
        long hour = cal.get(Calendar.HOUR_OF_DAY) * 3600; //获取小时-转为秒
        long minute = cal.get(Calendar.MINUTE) * 60; //获取分钟-转为秒
        long second = cal.get(Calendar.SECOND); //获取秒
        long zongms = hour + minute + second;

        if (!jb) {//判断今天是否是加班
            if (week == 0) {//0为周日，6为周六   0就加一天 6就加两天
                long lDate1 = (endTime.getTime()) / 1000L;
                long ms = lDate1 + (secondsInADay - zongms);
                long milliseconds = ms * 1000L; // 将秒数转换为毫秒数
                Date startDate = new Date(milliseconds); // 使用毫秒数创建Date对象
//                System.out.println("周日毫秒数创建成功");
                return startDate;
            } else if (week == 6) {
                long lDate1 = (endTime.getTime()) / 1000L;
                long ms = lDate1 + (secondsInADay - zongms) + secondsInADay;
                long milliseconds = ms * 1000L; // 将秒数转换为毫秒数
                Date startDate = new Date(milliseconds); // 使用毫秒数创建Date对象
//                System.out.println("周六毫秒数创建成功");
                return startDate;
            } else if (tx) {
                Date stdate = initializeDate(startTime);//10.2
                Date eddate = initializeDate(endTime);//10.6
                long day = getDay(stdate, eddate);//5
                Date notTx = new Date();
                if (day > 1) {//如果开始日期和结束日期为同一天 就只需要判断当天是否为调休日
                    long sTime = eddate.getTime();
                    Date newDate = new Date(sTime); // 使用毫秒数创建Date对象
//                    System.out.println("毫秒数创建成功" + newDate);
                    for (int i = 0; i < txDateList.size(); i++) {
                        if (sTime < txDateList.get(i).getTime()) {//如果小于 节假日 就加一天 然后拿加一天的日期和节假日比较
                            sTime += 86400000;
                            newDate = new Date(sTime);
//                            System.out.println("第" + i + "次 毫秒数创建成功" + newDate);
                        }
                        if (sTime == txDateList.get(i).getTime()) {//如果等于 节假日 就加一天 然后拿加一天的日期和节假日比较
                            sTime += 86400000;
                            newDate = new Date(sTime);
//                            System.out.println("第" + i + "次 毫秒数创建成功" + newDate);
                        }
                        if (i < txDateList.size() - 1) {
                            if (sTime < txDateList.get(i + 1).getTime()) {
                                notTx = new Date(sTime);
                                break;
                            }
                        } else {
                            notTx = new Date(sTime);
                            break;
                        }
                    }
//                    System.out.println("第一个非调休日期：" + notTx);//那么这个日期 是可能大于结束日期 如果大于，就给他提示一个该区间 没有非调休日期
                } else {
                    for (Date txL : txDateList) {
                        if (txL.getTime() == stdate.getTime()) {//说明是调休
                            notTx = new Date(txL.getTime());
                        } else {
                            //给他提示一个该区间 没有非调休日期

                        }
                    }
//                    System.out.println("调休日为：" + notTx);
                }
//                System.out.println("返回日期为：----------" + notTx);
                return notTx;
            }
        } else {
//            System.out.println("今天是工作日：" + endTime);
            return endTime;
        }
        return flag;
    }

    @Override
    public boolean verifyNowDateIsJb(Date nowTime) {

        //加班数据
        List<Date> jbDateList = new ArrayList<>();
        List<SpcyRsJjrk> jbList = list(new LambdaQueryWrapper<SpcyRsJjrk>()
                .eq(SpcyRsJjrk::getFjjrlx, SpcyConstant.JJRK_LX_JB));
        if (CollectionUtils.isNotEmpty(jbList)) {
            jbDateList = jbList.stream().map(SpcyRsJjrk::getFjjrsj).collect(Collectors.toList());
        }
        boolean jb = WorkDateUtils.isExists(nowTime, jbDateList);

        return jb;
    }

    @Override
    public boolean verifyNowDateIsTx(Date nowTime) {
        // 调休数据
        List<Date> txDateList = new ArrayList<>();
        List<SpcyRsJjrk> txList = list(new LambdaQueryWrapper<SpcyRsJjrk>()
                .eq(SpcyRsJjrk::getFjjrlx, SpcyConstant.JJRK_LX_TX));
        if (CollectionUtils.isNotEmpty(txList)) {
            txDateList = txList.stream().map(SpcyRsJjrk::getFjjrsj).collect(Collectors.toList());
        }
        boolean tx = WorkDateUtils.isExists(nowTime, txDateList);

        return tx;
    }

    private  boolean getWeekOfDate(Date date) {
        boolean[] weekDays = { false, true, true, true, true, true, false };
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        int w = cal.get(Calendar.DAY_OF_WEEK) - 1;
        if (w < 0)
            w = 0;
        return weekDays[w];
    }

    /**
     * @param: startTime , endTime
     * @Description: 计算两个日期想差的天数，不考虑任何
     * @auther: lhb
     * @date: 2023/9/6 16:51
     */
    private long getDay(Date startTime, Date endTime) {
        Instant instantst = startTime.toInstant();
        Instant instantend = endTime.toInstant();
        ZoneId zoneId = ZoneId.systemDefault();

        // atZone()方法返回在指定时区从此Instant生成的ZonedDateTime。
        LocalDate localDatest = instantst.atZone(zoneId).toLocalDate();
        LocalDate localDateend = instantend.atZone(zoneId).toLocalDate();

        int year = localDatest.getYear();
        int month1 = localDatest.get(ChronoField.MONTH_OF_YEAR);
        int day = localDatest.getDayOfMonth();

        int year1 = localDateend.getYear();
        int month2 = localDateend.get(ChronoField.MONTH_OF_YEAR);
        int day1 = localDateend.getDayOfMonth();

        LocalDate date1 = LocalDate.of(year, month1, day);
        LocalDate date2 = LocalDate.of(year1, month2, day1);
        long days = ChronoUnit.DAYS.between(date1, date2);
        return days;

    }

    /**
     * @param: datetime
     * @Description: 格式化日期
     * @auther: lhb
     * @date: 2023/9/6 17:54
     */
    private Date initializeDate(Date datetime) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(datetime);
        // 时
        calendar.set(Calendar.HOUR_OF_DAY, 0);
        // 分
        calendar.set(Calendar.MINUTE, 0);
        // 秒
        calendar.set(Calendar.SECOND, 0);

        Date time = calendar.getTime();
//        System.out.println(time);
        return time;
    }

}
